package com.wwz.leetcode;

import java.util.HashMap;
import java.util.Map;

/**
 * <p>Description:数组题目</p>
 * <p>Copyright: Copyright (c)2020</p>
 * <p>Company: Tope</p>
 * <P>Created Date :2020-06-03</P>
 * <P>@version 1.0</P>
 */
public class Array {

    public static void main(String[] args) {
        /*int[] nums = {5, 3, 1, 0, 2, 5, 3};
        findRepeatNumber2(nums);*/

        /*int[][] matrix = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
        int[] ints = spiralOrder(matrix);
        System.out.println(ints);*/

        int nums[] = {2, 7, 11, 15};
        int target = 26;
        int[] res =twoSum(nums,target);






    }

    /**
     * @Description:找出数组中重复的数字。 在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。
    数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。
    请找出数组中任意一个重复的数字。
    示例 1：
    输入：
    [2, 3, 1, 0, 2, 5, 3]
    输出：2 或 3
     * @create: 2020-06-03 19:42
     * @update logs
     * @throws Exception
     */
    public static int findRepeatNumber(int[] nums) {
        Map<String, Object> map = new HashMap<String, Object>();
        for (int c : nums) {

            if (map.get(String.valueOf(c)) != null) {
                map.put(String.valueOf(c), 2);
            } else {
                map.put(String.valueOf(c), 1);
            }
            if (Integer.parseInt(map.get(String.valueOf(c)).toString()) > 1) {
                System.out.println(c);
                return c;
            }
        }
        return 0;
    }

    /**
     * 方法二
     */
    public static int findRepeatNumber2(int[] nums) {
        int[] arr = new int[nums.length];
        for (int i = 0; i < nums.length; i++) {
            arr[nums[i]]++;
            if (arr[nums[i]] > 1) {
                System.out.println(nums[i]);
                return nums[i];
            }
        }
        return -1;
    }

    /**
     * @Description: 输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。
    示例 1：

    输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
    输出：[1,2,3,6,9,8,7,4,5]。
     * @create: 2020-06-05 15:34
     * @update logs
     * @throws Exception
     */
    public static int[] spiralOrder(int[][] matrix) {
        int hang = matrix.length, lie = matrix[0].length;
        int result[] = new int[hang * lie];
        int top = 0, bottom = matrix.length - 1, left = 0, right = matrix[0].length - 1;
        int index = 0;
        /*4 个边界，每次都要更新它们
        上边界 top : 0
        下边界 bottom : matrix.length - 1
        左边界 left : 0
        右边界 right : matrix[0].length - 1*/
        while (top < bottom && left < right){ //循环的条件

            for (int i = left; i < right ; i++) {  //上层
                result[index++] = matrix[top][i];
            }

            for (int i = top; i < bottom ; i++) {  //右侧
                result[index++] = matrix[i][right];
            }

            for (int i = right; i > left ; i--) {  //底层
                result[index++] = matrix[bottom][i];
            }
            for (int i = bottom; i > top ; i--) {  //左侧
                result[index++] = matrix[i][left];
            }

            left +=1;
            right -=1;
            bottom -=1;
            top +=1;
        }
        if (top == bottom) // 剩下一行，从左到右依次添加
            for (int i = left; i <= right; i++) {
                result[index++] = matrix[top][i];
            }
        else if (left == right) // 剩下一列，从上到下依次添加
            for (int i = top; i <= bottom; i++) {
                result[index++] = matrix[i][left];
            }
        return result;

    }

    /**
    * @Description: 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

     你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
     示例:
     给定 nums = [2, 7, 11, 15], target = 9
     因为 nums[0] + nums[1] = 2 + 7 = 9
     所以返回 [0, 1]
    * @create: 2020-06-11 9:38
    * @update logs
    * @throws Exception
    */
    public static int[] twoSum(int[] nums, int target) {
        int x = nums.length-1;
        for (int i = 0; i <= x-1 ; i++) {
            for (int j = i+1; j <= x; j++) {
                if((nums[i] + nums[j]) == target){
                    int res[] = {i,j};
                    return  res;
                }
            }
        }
        int notFound[] ={};
        return notFound;
    }
}